// 用户认证和本地存储管理工具
const STORAGE_KEYS = {
  USER_INFO: 'USER_INFO',           // 当前用户信息
  USER_LIST: 'USER_LIST',           // 用户列表（用于演示）
  USER_ROLE: 'USER_ROLE'            // 用户角色
}

const USER_ROLES = {
  CITIZEN: 'citizen',
  ADMIN: 'admin'
}

/**
 * 获取当前用户信息
 */
function getCurrentUser() {
  try {
    const userInfo = wx.getStorageSync(STORAGE_KEYS.USER_INFO)
    return userInfo || null
  } catch (error) {
    console.error('获取用户信息失败:', error)
    return null
  }
}

/**
 * 设置当前用户信息
 * @param {Object} userInfo 用户信息对象
 */
function setCurrentUser(userInfo) {
  try {
    // 不保存密码到本地，但保存完整的个人信息
    const safeUserInfo = {
      userId: userInfo.userId,
      username: userInfo.username,
      accountNumber: userInfo.accountNumber,
      role: userInfo.role,
      name: userInfo.name || '',
      email: userInfo.email || '',
      phone: userInfo.phone || '',
      avatar: userInfo.avatar || '',
      // 添加完整的个人信息字段
      idCard: userInfo.idCard || '',
      gender: userInfo.gender || '',
      birthDate: userInfo.birthDate || '',
      province: userInfo.province || '',
      city: userInfo.city || '',
      county: userInfo.county || '',
      village: userInfo.village || '',
      address: userInfo.address || '',
      postalCode: userInfo.postalCode || '',
      createdAt: userInfo.createdAt || new Date().toISOString(),
      lastLoginTime: new Date().toISOString()
    }
    
    wx.setStorageSync(STORAGE_KEYS.USER_INFO, safeUserInfo)
    wx.setStorageSync(STORAGE_KEYS.USER_ROLE, safeUserInfo.role)
    return true
  } catch (error) {
    console.error('保存用户信息失败:', error)
    return false
  }
}

/**
 * 清除当前用户信息
 */
function clearCurrentUser() {
  try {
    wx.removeStorageSync(STORAGE_KEYS.USER_INFO)
    wx.removeStorageSync(STORAGE_KEYS.USER_ROLE)
    return true
  } catch (error) {
    console.error('清除用户信息失败:', error)
    return false
  }
}

/**
 * 获取当前用户角色
 */
function getCurrentRole() {
  try {
    return wx.getStorageSync(STORAGE_KEYS.USER_ROLE) || null
  } catch (error) {
    console.error('获取用户角色失败:', error)
    return null
  }
}

/**
 * 检查是否为管理员
 */
function isAdmin() {
  return getCurrentRole() === USER_ROLES.ADMIN
}

/**
 * 检查是否为村民
 */
function isCitizen() {
  return getCurrentRole() === USER_ROLES.CITIZEN
}

/**
 * 检查用户是否已登录
 */
function isLoggedIn() {
  const userInfo = getCurrentUser()
  return userInfo !== null
}

/**
 * 添加用户到本地用户列表（用于演示和管理）
 * @param {Object} userData 用户数据
 */
function addUserToList(userData) {
  try {
    const users = wx.getStorageSync(STORAGE_KEYS.USER_LIST) || []
    
    // 检查用户是否已存在
    const existingUser = users.find(user => user.userId === userData.userId)
    if (existingUser) {
      return { success: false, message: '用户已存在' }
    }
    
    // 创建安全的用户数据（不包含密码）
    const safeUserData = {
      userId: userData.userId,
      username: userData.username,
      accountNumber: userData.accountNumber,
      role: userData.role,
      name: userData.name || '',
      email: userData.email || '',
      phone: userData.phone || '',
      avatar: userData.avatar || '',
      createdAt: userData.createdAt || new Date().toISOString(),
      status: 'active'
    }
    
    users.push(safeUserData)
    wx.setStorageSync(STORAGE_KEYS.USER_LIST, users)
    
    return { success: true, message: '用户添加成功', user: safeUserData }
  } catch (error) {
    console.error('添加用户失败:', error)
    return { success: false, message: '添加用户失败' }
  }
}

/**
 * 获取本地用户列表
 */
function getUserList() {
  try {
    return wx.getStorageSync(STORAGE_KEYS.USER_LIST) || []
  } catch (error) {
    console.error('获取用户列表失败:', error)
    return []
  }
}

/**
 * 根据用户ID查找用户
 * @param {string|number} userId 用户ID
 */
function findUserById(userId) {
  try {
    const users = getUserList()
    return users.find(user => user.userId == userId) || null
  } catch (error) {
    console.error('查找用户失败:', error)
    return null
  }
}

/**
 * 根据用户名查找用户
 * @param {string} username 用户名
 */
function findUserByUsername(username) {
  try {
    const users = getUserList()
    return users.find(user => user.username === username) || null
  } catch (error) {
    console.error('查找用户失败:', error)
    return null
  }
}

/**
 * 更新用户信息
 * @param {string|number} userId 用户ID
 * @param {Object} updateData 更新的数据
 */
function updateUser(userId, updateData) {
  try {
    const users = getUserList()
    const userIndex = users.findIndex(user => user.userId == userId)
    
    if (userIndex === -1) {
      return { success: false, message: '用户不存在' }
    }
    
    // 更新用户信息（不包含密码）
    users[userIndex] = {
      ...users[userIndex],
      ...updateData,
      updatedAt: new Date().toISOString()
    }
    
    wx.setStorageSync(STORAGE_KEYS.USER_LIST, users)
    
    // 如果是当前用户，同时更新当前用户信息
    const currentUser = getCurrentUser()
    if (currentUser && currentUser.userId == userId) {
      setCurrentUser(users[userIndex])
    }
    
    return { success: true, message: '用户信息更新成功', user: users[userIndex] }
  } catch (error) {
    console.error('更新用户失败:', error)
    return { success: false, message: '更新用户失败' }
  }
}

/**
 * 删除用户（软删除）
 * @param {string|number} userId 用户ID
 */
function deleteUser(userId) {
  try {
    const users = getUserList()
    const userIndex = users.findIndex(user => user.userId == userId)
    
    if (userIndex === -1) {
      return { success: false, message: '用户不存在' }
    }
    
    // 软删除：标记为已删除
    users[userIndex].deletedAt = new Date().toISOString()
    users[userIndex].status = 'deleted'
    
    wx.setStorageSync(STORAGE_KEYS.USER_LIST, users)
    
    return { success: true, message: '用户删除成功' }
  } catch (error) {
    console.error('删除用户失败:', error)
    return { success: false, message: '删除用户失败' }
  }
}

module.exports = {
  // 用户信息管理
  getCurrentUser,
  setCurrentUser,
  clearCurrentUser,
  
  // 角色管理
  getCurrentRole,
  isAdmin,
  isCitizen,
  isLoggedIn,
  
  // 用户列表管理
  addUserToList,
  getUserList,
  findUserById,
  findUserByUsername,
  updateUser,
  deleteUser,
  
  // 常量
  USER_ROLES,
  STORAGE_KEYS
}
